Concurrent checking for logic

TESTING IS NO longer good enough to ensure the quality of systems that must never fail. A highly reliable system must be able to detect and usually correct faults arising from test escapes, from aging or from the environment. For the most part, this has been done using techniques such as parity, error correcting codes, and redundancy. In particular, memories are designed with technologies so small as to make errors caused by cosmic ray hits inevitable, and memories with concurrent error detection and correction are now standard. Concern has existed for some time that random logic will fall prey to soft errors, and thus require online error checking and correction. The book under review examines precisely this area, presenting micro-level techniques for concurrent checking, which should be less expensive than high-level redundancy. Concurrent checking for logic alone is covered, which is an area in which a lot of new research is needed. First, a caveat: if you are new to concurrent checking, this is not the book for you. Although the authors spend some time on background, most of the book is devoted to highly specific solutions to the problem of concurrent checking, developed largely by various subsets of the authors in a considerable number of papers. Some background is assumed, and this is clearly stated. This volume consists of but four chapters, the first of which is a brief introduction. Most of the second chapter is an introduction to faults: stuck-at, stuckopen, bridging, transient, and delay. Finally, there is an introduction to the concepts of self-testing and self-checking, and a definition of output dependencies. Two outputs are independent under a fault if the effect of that fault can show up on only one of them for any set of inputs; they are weakly independent under a fault if an input that causes the effect to show up on one output but not on another. The chapter is well written, but little would be new to most test researchers. Chapter 3, approximately half of the book, describes specific methods of concurrent checking developed by the authors. They start with simple duplication and checking, then move on to parity checking. The principle here is to add a generator, which computes the parity of a combinational circuit output, and a predictor, which computes what the output parity should be, on the basis of the inputs. This prediction is done by synthesizing a duplicate version of the circuit, with no outputs except the predicted parity, which, the authors claim, will be reduced in size. The generated output parity and predicted parity are then compared. If outputs are independent, further improvements can be made. Chapter 3 exemplifies both the strengths and weaknesses of the book. The writing here, though complex, is clear, and a good example of concurrent checking is set forth. The authors give an excellent description of how this method works. However, because the book focuses on their work, we learn nothing at all of how other researchers have approached this problem. References are plentiful, but a large number are the authors’ work; many others are for general background. We do not get a sense of the history of this problem, nor of how the Book Reviews